import messageCenter from '@/common/utils/messagecenter.js'
import {
	baseUrl
} from '@/common/utils/request';

const result = baseUrl.replace("http:", "");
console.log(result)

// 1. 全局变量：存储 socket 实例和连接状态
export let socket = null; // 导出 socket 实例，供外部引用
export let socketStatus = "closed"; // 导出连接状态：closed/connecting/connected/error

// 心跳机制相关变量
let heartbeatTimer = null; // 心跳定时器
let heartbeatInterval = 30000; // 心跳间隔（30秒）
let reconnectTimer = null; // 重连定时器
let reconnectCount = 0; // 重连次数
let maxReconnectCount = 5; // 最大重连次数
let isManualClose = false; // 是否手动关闭

// 2. 初始化 WebSocket 连接的函数（需在用户登录后调用）
export function initSocket() {
	// 获取已登录的用户信息（确保在登录后调用此函数）
	const user = uni.getStorageSync("user_info");

	if (!user || !user.userId) {
		console.error("用户信息不存在或无 ID，无法初始化 WebSocket 连接");
		return;
	}

	// 避免重复创建连接
	if (socketStatus === "connected" || socketStatus === "connecting") {
		console.log("WebSocket 已处于连接状态，无需重复创建");
		return;
	}

	// 清除之前的重连定时器
	if (reconnectTimer) {
		clearTimeout(reconnectTimer);
		reconnectTimer = null;
	}

	isManualClose = false
	socketStatus = "connecting";
	const token = uni.getStorageSync("token"); // 从登录后存储的地方获取

	// 创建 WebSocket 连接
	// 注意：由于uni-app的uni.connectSocket不支持自定义header
	// 所以通过URL参数传递token，网关会验证并移除该参数
	socket = uni.connectSocket({
		url: `ws:${result}/api/chat/connect?token=${token}`,
		success: () => {
			console.log("WebSocket 连接请求已发送");
		},
		fail: (err) => {
			console.error("WebSocket 连接请求失败：", err);
			socketStatus = "error";
			// 尝试重连
			handleReconnect();
		}
	});

	// 连接成功事件
	socket.onOpen((res) => {
		console.log("WebSocket 连接成功...", res);
		socketStatus = "connected";
		reconnectCount = 0; // 重置重连次数
		uni.setStorageSync("socketStatus", socketStatus);

		// 启动心跳
		// startHeartbeat();
	});

	// 接收消息事件
	socket.onMessage((res) => {
		try {
			const message = JSON.parse(res.data);
			console.log("收到 WebSocket 消息：", message);

			// 处理心跳响应
			if (message.type === 'pong' || message.messageType === 'pong') {
				console.log("收到心跳响应");
				return;
			}

			// 处理普通消息
			message.type = "receive";
			console.log("处理普通消息：", message);
			messageCenter.saveMessage(message);
		} catch (error) {
			console.error("解析消息失败：", error);
		}
	});

	// 连接错误事件
	socket.onError((err) => {
		console.error("WebSocket 连接错误：", err);
		socketStatus = "error";
		uni.setStorageSync("socketStatus", socketStatus);
		stopHeartbeat();
	});

	// 连接关闭事件
	socket.onClose((res) => {
		console.log("WebSocket 连接关闭：", res);
		socketStatus = "closed";
		uni.setStorageSync("socketStatus", socketStatus);
		stopHeartbeat();

		// 如果不是手动关闭，则尝试重连
		if (!isManualClose) {
			handleReconnect();
		}
	});
}

// 3. 心跳机制 - 发送心跳包
function startHeartbeat() {
	stopHeartbeat(); // 先清除之前的定时器

	heartbeatTimer = setInterval(() => {
		if (socketStatus === "connected") {
			sendHeartbeat();
		} else {
			stopHeartbeat();
		}
	}, heartbeatInterval);
}

// 发送心跳包
function sendHeartbeat() {
	if (socketStatus === "connected" && socket) {
		try {
			uni.sendSocketMessage({
				data: JSON.stringify({
					type: 'ping',
					messageType: 'ping',
					time: new Date().toISOString()
				}),
				success: () => {
					console.log("心跳发送成功");
				},
				fail: (err) => {
					console.error("心跳发送失败：", err);
					stopHeartbeat();
				}
			});
		} catch (error) {
			console.error("发送心跳异常：", error);
		}
	}
}

// 停止心跳
function stopHeartbeat() {
	if (heartbeatTimer) {
		clearInterval(heartbeatTimer);
		heartbeatTimer = null;
	}
}

// 4. 重连机制
function handleReconnect() {
	// 清除之前的重连定时器
	if (reconnectTimer) {
		clearTimeout(reconnectTimer);
		reconnectTimer = null;
	}

	// 检查是否超过最大重连次数
	if (reconnectCount >= maxReconnectCount) {
		console.error("已达到最大重连次数，停止重连");
		uni.showToast({
			title: '网络连接失败',
			icon: 'none'
		});
		return;
	}

	// 检查用户是否仍然登录
	const user = uni.getStorageSync("user_info");
	if (!user || !user.userId) {
		console.log("用户未登录，停止重连");
		return;
	}

	reconnectCount++;
	const delay = Math.min(1000 * Math.pow(2, reconnectCount - 1), 30000); // 指数退避，最大30秒

	console.log(`准备第 ${reconnectCount} 次重连，延迟 ${delay}ms`);

	reconnectTimer = setTimeout(() => {
		console.log(`执行第 ${reconnectCount} 次重连`);
		initSocket();
	}, delay);
}

// 5. 导出发送消息的函数
export function sendSocketMessage(data) {
	return new Promise((resolve, reject) => {
		if (socketStatus !== "connected") {
			console.error(`WebSocket 处于 ${socketStatus} 状态，无法发送消息`);

			// 尝试重连
			if (socketStatus === "closed") {
				initSocket();
			}

			reject(new Error('WebSocket未连接'));
			return false;
		}

		uni.sendSocketMessage({
			data: JSON.stringify(data),
			success: () => {
				console.log("消息发送成功：", data);
				resolve(true);
			},
			fail: (err) => {
				console.error("消息发送失败：", err);
				reject(err);
			}
		});
	});
}

// 6. 检查 WebSocket 是否已连接
export function isSocketConnected() {
	return socketStatus === "connected";
}

// 7. 手动关闭 WebSocket 连接
export function closeSocket() {
	isManualClose = true;
	stopHeartbeat();

	if (reconnectTimer) {
		clearTimeout(reconnectTimer);
		reconnectTimer = null;
	}

	if (socket) {
		uni.closeSocket({
			success: () => {
				console.log("WebSocket 已手动关闭");
			}
		});
	}

	socketStatus = "closed";
	socket = null;
}

// 8. 重置重连次数（用于网络恢复后）
export function resetReconnectCount() {
	reconnectCount = 0;
}